
/*
 * Funambol is a mobile platform developed by Funambol, Inc. 
 * Copyright (C) 2003 - 2007 Funambol, Inc.
 * 
 * This program is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Affero General Public License version 3 as published by
 * the Free Software Foundation with the addition of the following permission 
 * added to Section 15 as permitted in Section 7(a): FOR ANY PART OF THE COVERED
 * WORK IN WHICH THE COPYRIGHT IS OWNED BY FUNAMBOL, FUNAMBOL DISCLAIMS THE 
 * WARRANTY OF NON INFRINGEMENT  OF THIRD PARTY RIGHTS.
 * 
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 * details.
 * 
 * You should have received a copy of the GNU Affero General Public License 
 * along with this program; if not, see http://www.gnu.org/licenses or write to
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 * MA 02110-1301 USA.
 * 
 * You can contact Funambol, Inc. headquarters at 643 Bair Island Road, Suite 
 * 305, Redwood City, CA 94063, USA, or at email address info@funambol.com.
 * 
 * The interactive user interfaces in modified source and object code versions
 * of this program must display Appropriate Legal Notices, as required under
 * Section 5 of the GNU Affero General Public License version 3.
 * 
 * In accordance with Section 7(b) of the GNU Affero General Public License
 * version 3, these Appropriate Legal Notices must retain the display of the
 * "Powered by Funambol" logo. If the display of the logo is not reasonably 
 * feasible for technical reasons, the Appropriate Legal Notices must display
 * the words "Powered by Funambol". 
 */

package com.funambol.storage;

import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import javax.microedition.rms.RecordStoreException;

public class ReadWriteMidlet extends MIDlet implements CommandListener {
    
    public static final String STORENAME = "DummyStore";
    
    /** 
     * Creates a new instance of ReadWriteMIDlet 
     */
    public ReadWriteMidlet() {
        initialize();
    }
    
    private Form mainForm;
    private Command writeRecord;
    private Command readRecords;
    private Command exitMidletCommand;
    private Form readForm;
    private Command backFromReadCommand;
    private ObjectStore objs;
    private TestClass storedClass; 
    private TestContainer storedContainer; 
    
    /** 
     * This method initializes the application.
     */
    private void initialize() {
        storedClass = new TestClass("storedHt");
        storedContainer = new TestContainer(storedClass);
        objs = new ObjectStore();
        try {
            objs.create(STORENAME);
        } catch (RecordStoreException ex) {
            ex.printStackTrace();
        }
        getDisplay().setCurrent(get_mainForm());
    }
    
    /**
     * @return Dispaly an instance of the display.
     */
    public Display getDisplay() {                         
        return Display.getDisplay(this);
    }                        
    
    /** 
     * @return Instance for mainForm component
     */
    public Form get_mainForm() {
        if (mainForm == null) {
            
            mainForm = new Form("Main Form", new Item[0]);
            mainForm.addCommand(get_readRecords());
            mainForm.addCommand(get_writeRecord());
            mainForm.addCommand(get_exitMidletCommand());
            mainForm.setCommandListener(this);
        
        }
        return mainForm;
    }

    /** 
     * @return Instance for writeRecord component
     */
    public Command get_writeRecord() {
        if (writeRecord == null) {
            
            writeRecord = new Command("write", Command.OK, 1);
        
        }
        return writeRecord;
    }

    /** 
     * @return Instance for readRecords component
     */
    public Command get_readRecords() {
        if (readRecords == null) {
        
            readRecords = new Command("read", Command.OK, 2);
        
        }
        return readRecords;
    }

    /**
     * @return Instance for exitMidletCommand component
     */
    public Command get_exitMidletCommand() {
        if (exitMidletCommand == null) {
            exitMidletCommand = new Command("Back", Command.EXIT, 1);
        }
        return exitMidletCommand;
    }

    /** 
     * @return Instance for readForm component
     */
    public Form get_readForm() {
        if (readForm == null) {
            readForm = new Form("Written Records", new Item[0]);
            readForm.addCommand(get_backFromReadCommand());
            readForm.setCommandListener(this);
        }
        return readForm;
    }

    /**
     * @return Instance for backFromReadCommand component
     */
    public Command get_backFromReadCommand() {
        if (backFromReadCommand == null) {
        
            backFromReadCommand = new Command("Back", Command.BACK, 1);
        
        }
        return backFromReadCommand;
    }
    
    /** 
     * Command Flow State Machine:
     * @param command the Command that was invoked
     * @param displayable the Displayable on which the command was invoked
     */
    public void commandAction(Command command, Displayable displayable) {
        if (displayable == mainForm) {
            if (command == exitMidletCommand) {
                
                exitMIDlet();
            
            } else if (command == writeRecord) {
                writeObjsRecord(objs);
                exitMIDlet();
            
            } else if (command == readRecords) {
                
                getDisplay().setCurrent(get_readForm());
                readObjsRecord(objs);
            }
        } else if (displayable == readForm) {
            if (command == backFromReadCommand) {
                
                getDisplay().setCurrent(get_mainForm());
            
            }
        }
    }
    
    /**
     * Exit the midlet.
     */
    public void exitMIDlet() {                         
        getDisplay().setCurrent(null);
        destroyApp(true);
        notifyDestroyed();
    }                        
    
    /**
     * Writes some record to the given recordstore
     * @param objs is the ObjectStore on which records will be written
     */
    private void writeObjsRecord(ObjectStore objs) {
        try {
            objs.open(STORENAME);
            objs.store(storedClass);
            objs.store(storedContainer);
            objs.close();
        } catch (IOException ex) {
            ex.printStackTrace();
        } catch (RecordStoreException ex) {
            ex.printStackTrace();
        }
    }
    
    /**
     * Writes some record to the given recordstore
     * @param objs is the ObjectStore on which records will be written
     */
    private void readObjsRecord(ObjectStore objs) {
        TestClass actualStoredClass = null;
        TestContainer actualStoredContainer = null;
        try {
            objs.open(STORENAME);
            actualStoredClass = (TestClass) objs.retrieve(1, new TestClass());
            actualStoredContainer = (TestContainer) objs.retrieve(2, new TestContainer());
            objs.close();
            readForm.append(actualStoredClass.toString());
            readForm.append(actualStoredContainer.toString());
        } catch (IOException ex) {
            ex.printStackTrace();
        } catch (RecordStoreException ex) {
            ex.printStackTrace();
        }
    }
        
    public void startApp() {
    }
    
    public void pauseApp() {
    }
    
    public void destroyApp(boolean unconditional) {
    }
}
